package org.example.singleton;

import java.util.Arrays;

/**
 * 单例模式
 * @author wangbin
 * @date 2024/4/17
 * @vesion 1.0
 */
public class SingletonDemo {


    public static void main(String[] args) {
        SingletonDemo1 singletonDemo1 = SingletonDemo1.getInstance();   // 饿汉式（静态变量）
        SingletonDemo1 singletonDemo2 = SingletonDemo1.getInstance();   // 饿汉式（静态变量）

        System.out.println("singletonDemo1 = " +singletonDemo1.hashCode());
        System.out.println("singletonDemo2 = " +singletonDemo2.hashCode());
    }

}

/**
 *  饿汉式（静态变量）
 */
class SingletonDemo1 {
    //1.构造器私有化，外部能new
    private SingletonDemo1(){

    }
    // 2.本类内部创建对象实例
    private final static SingletonDemo1 instance = new SingletonDemo1();   // 饿汉式（静态变量）  饿汉式（静态变量）

    // 3. 提供一个公有的静态方法，返回实例对象
    public static SingletonDemo1 getInstance(){   // 饿汉式（静态变量）
        return instance;
    }

}



/**
 *  饿汉式（静态代码块）
 */
class SingletonDemo2 {
    //1.构造器私有化，外部能new
    private SingletonDemo2(){

    }
    // 2.本类内部创建对象实例
    private static SingletonDemo2 instance ;   // 饿汉式（静态代码块）

    static {
        // 静态代码块中，创建单例对象
        instance  = new SingletonDemo2();   // 饿汉式（静态代码块）
    }
    // 3. 提供一个公有的静态方法，返回实例对象
    public static SingletonDemo2 getInstance(){   // 饿汉式（静态代码块）
        return instance;
    }

}



/**
 *  懒汉式（线程不安全）
 */
class SingletonDemo3 {
    // 2.本类内部创建对象实例
    private static SingletonDemo3 instance ;   // 懒汉式（线程不安全）

    private SingletonDemo3(){

    }
    // 3. 提供一个公有的静态方法，当使用该方法时，才去创建 instance
    public static SingletonDemo3 getInstance(){   // 懒汉式（线程不安全）
        if(instance == null){
            return new SingletonDemo3();   // 懒汉式（线程不安全）
        }
        return instance;
    }

}



/**
 *  懒汉式（线程不安全 +方法的同步锁）
 */
class SingletonDemo4 {
    // 2.本类内部创建对象实例
    private static SingletonDemo4 instance ;   // 懒汉式（线程不安全 +方法的同步锁）

    private SingletonDemo4(){

    }
    // 3. 提供一个公有的静态方法，当使用该方法时，才去创建 instance
    public static synchronized SingletonDemo4 getInstance(){   // 懒汉式（线程不安全 +方法的同步锁）
        if(instance == null){
            instance = new SingletonDemo4();   // 懒汉式（线程不安全 +方法的同步锁）
        }
        return instance;
    }

}


/**
 *  懒汉式（线程不安全 +同步代码块）
 */
class SingletonDemo5 {
    // 2.本类内部创建对象实例
    private static SingletonDemo5 instance ;   // 懒汉式（线程不安全 +同步代码块）

    private SingletonDemo5(){

    }
    // 3. 提供一个公有的静态方法，当使用该方法时，才去创建 instance
    public static SingletonDemo5 getInstance(){   // 懒汉式（线程不安全 +同步代码块）
        // 同步锁
        synchronized (SingletonDemo5.class) {   // 懒汉式（线程不安全 +同步代码块）
            if(instance == null){
                instance= new SingletonDemo5();   // 懒汉式（线程不安全 +同步代码块）
            }
        }
        return instance;
    }

}



/**
 *  懒汉式双重检查
 */
class SingletonDemo6 {
    // 2.本类内部创建对象实例
    private static volatile SingletonDemo6 instance ;   // 懒汉式双重检查

    private SingletonDemo6(){

    }
    // 3. 提供一个公有的静态方法，当使用该方法时，才去创建 instance
    public static SingletonDemo6 getInstance(){   // 懒汉式双重检查
        // 同步锁
        synchronized (SingletonDemo6.class) {   // 懒汉式双重检查
            if(instance == null){
                instance= new SingletonDemo6();   // 懒汉式双重检查
            }
        }
        return instance;
    }

}




/**
 *  静态内部类
 */
class SingletonDemo7 {
    // 2.本类内部创建对象实例
    //private static volatile SingletonDemo7 instance ;

    private SingletonDemo7(){

    }

    // 静态内部类
    private static class SingletonInstance{
        private static final  SingletonDemo7 instance = new SingletonDemo7();   // 静态内部类  静态内部类
    }

    // 3. 提供一个公有的静态方法，当使用该方法时，才去创建 instance
    public static synchronized SingletonDemo7 getInstance(){   // 静态内部类

        return SingletonInstance.instance;
    }

}


/**
 *  枚举类
 */
enum SingletonDemo8 {
    INSTANCE;
    public void sys(){

    }
}





